As the cost and availability of processors decreases, there has been increasing interest in coupling many processors together to provide the huge amounts of computing power required to solve previously intractable problems. Among applications that are thought to be amenable to solution with such massively parallel machines are problems involving weather prediction, climate and ocean current modeling, nuclear fusion reactor modeling, dynamic modeling of galactic collisions, assembling decoded fragments of DNA into chromosome-level DNA databases, and similar tasks involving large numbers of variables and large datasets.
Several architectures have been previously disclosed for parallel processing, including the Howard Cascade. Hardware alone, however, does not solve applications; software must be prepared to direct the hardware into finding a solution.
While software development for single processor machines, and for machines providing limited parallelism, has reached a high state of art; methods have not previously been perfected for subdividing massive problems into subtasks, submitting and executing those subtasks on many processors in a massively parallel processor, and collecting and refining results into useful solutions.
For expediency, modern computer software is usually created in a quasi-ad-hoc fashion. That is, design is simply a sketch that the programmer uses as a guide in some iterative development effort in order to reduce development time, allowing for enhanced time-to-market. Unfortunately, on average, 70 software bugs per 1,000 lines of software generated occur. Thus, for a one million source-line software system with, on average, 7000 bugs, detecting and repairing the bugs both during testing and after product release costs $2,461,200.
Traditionally, the documentation that comprises a design quickly gets out of sync with the software. Maintaining both the software and the design documentation is twice the effort, without twice the net benefit to the organization, because there is usually no direct causal relationship between the code and the documentation. A model that allows most of the code to be generated automatically from the design documentation, without coding constructs being placed in that documentation, and that creates a change in the code whenever a change is made to the documentation makes the double effort unnecessary.
Automatic Code Generation Methods
There are currently three standard models of automatic software generators: design patterns, domain meta-data usage, and domain rules.
Design Pattern
A design pattern occurs when a coding template is used with some user-defined data to create the software. For instance, adherence to a particular Application Programming Interface (API) standard as a template allows code to be generated to that standard.
Domain Meta-Data
In the domain of database designs, databases can be created from entity-relationship diagrams which comprise the meta-data defining the interactions that can be used in a particular database.
Domain Rules
Domain rules are any set of rules used within a particular knowledge area. In the domain of bioinformatics, the rules describing the translation of DNA to proteins comprise that field's domain rules. When the rules are precise enough, they can be used to generate software in that domain.
What is missing from existing automatic code generators is a generally applicable automatic code-generation solution.
The term Howard Cascade as used herein refers to a category of massively parallel computing systems as disclosed in U.S. Pat. Nos. 6,857,004, 7,418,470, and 7,730,121, US Patent Publications 20050038852, 20100185719, 20100049941, 20100094924, 20100183028 and 20090077483, the disclosures of which are incorporated herein by reference. Howard Cascades typically have one or more access or home nodes or machines, one or more processing nodes or machines, and a communications system interconnecting the access nodes and processing nodes. During program execution, processing nodes are typically dynamically organized into a hierarchical cascade.